const { randomNum } = require('../utils');

const reg_mark = /^(.+?)\s/;
const reg_sharp = /^\#/;
const reg_crossbar = /^\-/;
const reg_number = /^\d/;

// 转html 字符串
function compileHTML(_mdArr) {
  // console.log(_mdArr);
  const _htmlPool = createTree(_mdArr);
  // console.log(_htmlPool);
  let _htmlStr = '';
  let item;

  for (let k in _htmlPool) {
    item = _htmlPool[k];

    if (item.type === 'single') {
      item.tags.forEach(tagContent => {
        _htmlStr += tagContent;
      })
    } else if (item.type === 'wrap') {
      let _list = `<${k.split('-')[0]}>`;
      
      item.tags.forEach(tagContent => {
        _list += tagContent;
      })

      _list += `</${k.split('-')[0]}>`;
      _htmlStr += _list;
    }
  }
  // console.log(_htmlStr);

  return _htmlStr;
}

function createTree(mdArr) { // 构建数据树
  let _htmlPool = {};
  let _lastMark = ''; // 上一组匹配到的标签
  let _key = ''; // 添加给标签的随机标识 处理出现重复标签的情况

  mdArr.forEach(mdFragment => {
    // 匹配标签
    const matched = mdFragment.match(reg_mark);
    // console.log(matched);

    if (matched) {
      const mark = matched[1];
      const input = matched['input'];

      if (reg_sharp.test(mark)) { // 处理标题标签
        const tag = `h${mark.length}`;
        const tagContent = input.replace(reg_mark, '');
        const former = `<${tag}>${ tagContent }</${tag}>`;

        if (_lastMark === mark) {
          // 如果相同就是同一组标签 就添加当前内容
          _htmlPool[`${tag}-${_key}`].tags = [..._htmlPool[`${tag}-${_key}`].tags, former];

        } else {
          _lastMark = mark; // 不是就重新赋值当前的标签
          _key = randomNum();
          _htmlPool[`${tag}-${_key}`] = {
            type: 'single',
            tags: [former]
          }
        }
      }

      if (reg_crossbar.test(mark)) { // 处理无序列表
        const tag = 'li';
        const tagContent = input.replace(reg_mark, '');
        const former = `<${tag}>${ tagContent }</${tag}>`;
        
        if (reg_crossbar.test(_lastMark)) {
          _htmlPool[`ul-${_key}`].tags = [..._htmlPool[`ul-${_key}`].tags, former];
        } else {
          _lastMark = mark;
          _key = randomNum();
          _htmlPool[`ul-${_key}`] = {
            type: 'wrap',
            tags: [former]
          }
        }
      }

      if (reg_number.test(mark)) { // 处理有序列表
        const tag = 'li';
        const tagContent = input.replace(reg_mark, '');

        if (reg_number.test(_lastMark)) {
          _htmlPool[`ol-${_key}`].tags = [..._htmlPool[`ol-${_key}`].tags, `<${tag}>${ tagContent }</${tag}>`];
        } else {
          _lastMark = mark;
          _key = randomNum();
          _htmlPool[`ol-${_key}`] = {
            type: 'wrap',
            tags: [`<${tag}>${ tagContent }</${tag}>`]
          }
        }
      }
    }
  })

  return _htmlPool;
}

module.exports = {
  compileHTML
}

/**
 * {
    'h1-165027396062657469c465ffcf': { type: 'single', tags: [ '<h1>这是一个h1的标题\r</h1>' ] },
    'ul-1650273960627e144d5191870d': {
      type: 'wrap',
      tags: [
        '<li>这是UL列表第1项\r</li>',
        '<li>这是UL列表第2项\r</li>',
        '<li>这是UL列表第3项\r</li>',
        '<li>这是UL列表第4项\r</li>'
      ]
    },
    'h2-16502739606271f06d752098a6': { type: 'single', tags: [ '<h2>这是一个h2的标题\r</h2>' ] },   
    'ol-16502739606272ffc41a37c799': {
      type: 'wrap',
      tags: [
        '<li>这是OL列表第1项\r</li>',
        '<li>这是OL列表第2项\r</li>',
        '<li>这是OL列表第3项\r</li>',
        '<li>这是OL列表第4项</li>'
      ]
    }
  }
 */

/**
 * 数据结构
 * 
 * [
    '# 这是一个h1的标题\r', 
    '\r',
    '- 这是UL列表第1项\r',  
    '- 这是UL列表第2项\r',
    '- 这是UL列表第3项\r',
    '- 这是UL列表第4项\r',
    '\r',
    '## 这是一个h2的标题\r',
    '\r',
    '1. 这是OL列表第1项\r',
    '2. 这是OL列表第2项\r',
    '3. 这是OL列表第3项\r',
    '4. 这是OL列表第4项'
  ]
 * 
 * {
 *  h1: {
 *    type: 'single',
 *    tags: ['<h1>这是一个h1的标题</h1>']
 *  },
 *  ul(遇到重复标签时可以添加标识: ul-784512): {
 *    type: 'wrap',
 *    tags: [
 *      '<li>这是UL列表第1项</li>',
 *      '<li>这是UL列表第2项</li>',
 *      '<li>这是UL列表第3项</li>',
 *      '<li>这是UL列表第4项</li>'
 *    ]
 *  }
 * }
 * 
 * 
 */